/*!
\file
	DataTypesManager.cpp
\brief
	Definition of DataTypesManager.
\author
	Copyright (C) 2008 Vadym Hulakov, mailto:hulakov@gmail.com.
	All rights reserved.
*/

#include "TypeHierarchy.h"
#include "BasicType.h"
#include <algorithm>

//#include "DataTypeInfo.h"
//#include "Exceptions.h"
//#include "SerializebleMap.h"
//#include "UncompleteDataTypeInfo.h"
//#include "ClassDataTypeInfo.h"
//#include "BasicDataTypesInfo.h"

namespace ObjectModel
{
	TypeHierarchy::TypeHierarchy(const wchar_t* name/* = L"fooHierarchy"*/)
	{
		_name = name;
		createBasicTypes();
	}

	TypeHierarchy::~TypeHierarchy(void)
	{
		for (const_iterator i = begin(); i != end(); ++i)
			delete i->second;
		//std::for_each(begin(), end(), [](TypeMap::const_reference item) {
		//	delete item.second;
		//});
	}

	void TypeHierarchy::addBasicType(const wchar_t* name, int size)
	{
		BasicType* type = new BasicType(name, *this, size);
		insert(value_type(name, type));
	}

	void TypeHierarchy::createBasicTypes()
	{
		addBasicType(L"int", 4);
		addBasicType(L"double", 8);
		addBasicType(L"bool", 1);
		addBasicType(L"wchar_t", 2);
		addBasicType(L"void", 0);
	}

	ClassType& TypeHierarchy::addClass(const wchar_t* name, const wchar_t* description/* = 0*/)
	{
		ClassType* type = new ClassType(name, *this, description);
		insert(value_type(name, type));
		return *type;
	}
//
//DataTypeInfo& TypeHierarchy::get_data_type(const std::wstring& name, bool create_empty_classes)
//{
//	return get_data_type(name.c_str(), create_empty_classes);
//}
//
	Type* TypeHierarchy::lookup(const wchar_t* name) const
	{
		const_iterator it = find(name);
		Type* result = it != end() ? it->second : 0;
		return result;
	}
//
//int TypeHierarchy::get_data_types_count()
//{
//	return (int)(size());
//}
//
//UserDataTypeInfo& TypeHierarchy::get_or_create_class(const std::wstring& name)
//{
//	return get_or_create_class(name.c_str());
//}
//
//DataTypeInfo* TypeHierarchy::is_class_exists(const wchar_t* name)
//{
//	iterator res = find(name);
//	return res == end() ? 0 : res->second;
//}
//
//DataTypeInfo* TypeHierarchy::is_class_exists(const std::wstring& name)
//{
//	return is_class_exists(name.c_str());
//}
//
//UserDataTypeInfo& TypeHierarchy::get_or_create_class(const wchar_t* name)
//{
//	DataTypeInfo* info = is_class_exists(name);
//	if (!info)
//		return create_class(name);
//	UserDataTypeInfo* user_type_info = dynamic_cast<UserDataTypeInfo*>(info);
//	if (user_type_info == 0)
//		throw Exception(L"%0% is not user data type", name);
//	else
//		return *user_type_info;
//}
//
//void TypeHierarchy::perform_serialize(SerializationContext& context)
//{
//	DataTypeMap::perform_serialize(context);
//	if (!context.is_saving())
//		set_data_types_poiters(false);
//}
//
//UserDataTypeInfo& TypeHierarchy::create_class(const wchar_t* name)
//{
//	ClassDataTypeInfo *info = new ClassDataTypeInfo(name);
//	add_data_type(info);
//	return *info;
//}
}
